Sécurité FastAPI : CORS et en-têtes de sécurité pour des API robustes

Dans le paysage numérique interconnecté d'aujourd'hui, la sécurisation de vos API est primordiale. FastAPI, un framework web moderne et performant pour la création d'API avec Python, offre d'excellents outils et fonctionnalités pour mettre en œuvre des mesures de sécurité robustes. Ce guide complet explore deux aspects critiques de la sécurité FastAPI : le partage de ressources cross-origin (CORS) et les en-têtes de sécurité. En comprenant et en mettant en œuvre ces techniques, vous pouvez améliorer considérablement la protection de votre API contre les vulnérabilités web courantes.

Comprendre CORS (Cross-Origin Resource Sharing - Partage de ressources cross-origin)

CORS est un mécanisme de sécurité des navigateurs qui empêche les pages web de faire des requêtes vers un domaine différent de celui qui a servi la page web. Cette politique est en place pour empêcher les sites web malveillants d'accéder aux données sensibles d'autres sites web sans autorisation appropriée. Sans CORS, un site web malveillant pourrait potentiellement faire des requêtes non autorisées à votre API au nom d'un utilisateur connecté, entraînant des violations de données ou d'autres exploits de sécurité.

Pourquoi CORS est-il nécessaire ?

Imaginez un scénario où un utilisateur est connecté à son compte bancaire en ligne. Simultanément, il visite un site web malveillant. Sans CORS, le site web malveillant pourrait potentiellement exécuter du code JavaScript qui envoie des requêtes à l'API bancaire de l'utilisateur, transférant des fonds sur le compte de l'attaquant. CORS empêche cela en appliquant une politique de même origine par défaut.

Comment fonctionne CORS

Lorsqu'un navigateur effectue une requête cross-origin (une requête vers une origine différente de la page actuelle), il effectue d'abord une requête "preflight" en utilisant la méthode HTTP OPTIONS. Cette requête preflight vérifie auprès du serveur pour déterminer si la requête réelle est autorisée. Le serveur répond avec des en-têtes qui indiquent quelles origines, méthodes et en-têtes sont autorisés. Si le navigateur détermine que la requête est autorisée sur la base de la réponse du serveur, il procède à la requête réelle. Sinon, la requête est bloquée.

L'"origine" est définie par le protocole (par exemple, HTTP ou HTTPS), le domaine (par exemple, example.com) et le port (par exemple, 80 ou 443). Deux URL sont considérées comme étant de la même origine uniquement si ces trois composants correspondent exactement.

Configuration de CORS dans FastAPI

FastAPI simplifie le processus de configuration de CORS en utilisant le CORSMiddleware. Vous pouvez ajouter ce middleware à votre application FastAPI pour activer CORS et spécifier les origines, les méthodes et les en-têtes autorisés.

Voici un exemple de base de la façon d'activer CORS dans FastAPI :

            
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

origins = [
    "http://localhost",
    "http://localhost:8080",
    "https://example.com",
    "https://*.example.com",  # Autoriser tous les sous-domaines de example.com
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

@app.get("/")
async def read_root():
    return {"message": "Hello, World!"}

            

              
                Copy
              
            
          

Dans cet exemple :

• allow_origins : Spécifie une liste d'origines autorisées à faire des requêtes cross-origin. Utiliser ["*"] autorise toutes les origines, ce qui est généralement déconseillé pour les environnements de production. Au lieu de cela, spécifiez les origines exactes qui doivent être autorisées.
• allow_credentials : Indique s'il faut autoriser les informations d'identification (par exemple, les cookies, les en-têtes d'autorisation) à être incluses dans les requêtes cross-origin. Définir cette valeur sur True nécessite que l'en-tête Access-Control-Allow-Origin soit défini sur une origine spécifique, et non sur *.
• allow_methods : Spécifie une liste des méthodes HTTP autorisées pour les requêtes cross-origin. Utiliser ["*"] autorise toutes les méthodes. Vous pouvez restreindre cela à des méthodes spécifiques comme ["GET", "POST", "PUT", "DELETE"] pour une sécurité accrue.
• allow_headers : Spécifie une liste des en-têtes HTTP autorisés dans les requêtes cross-origin. Utiliser ["*"] autorise tous les en-têtes. Envisagez de restreindre cela aux seuls en-têtes nécessaires pour une sécurité améliorée.

Meilleures pratiques pour la configuration de CORS

• Évitez d'utiliser ["*"] pour allow_origins en production : Cela ouvre votre API aux requêtes de n'importe quelle origine, ce qui peut être un risque de sécurité. Au lieu de cela, listez explicitement les origines autorisées.
• Soyez précis avec les méthodes et les en-têtes autorisés : Autorisez uniquement les méthodes et les en-têtes qui sont réellement nécessaires par votre application.
• Comprenez les implications de allow_credentials : Si vous autorisez les informations d'identification, assurez-vous de comprendre les implications de sécurité et de configurer votre serveur en conséquence.
• Examinez régulièrement votre configuration CORS : Au fur et à mesure que votre application évolue, votre configuration CORS peut avoir besoin d'être mise à jour pour refléter les changements dans vos origines, méthodes ou en-têtes autorisés.

Mise en œuvre des en-têtes de sécurité

Les en-têtes de sécurité sont des en-têtes de réponse HTTP qui fournissent des instructions au navigateur sur la façon de se comporter lors du traitement de votre site web ou de votre API. Ils aident à atténuer diverses vulnérabilités web, telles que les attaques de cross-site scripting (XSS), le clickjacking et d'autres attaques. La configuration correcte de ces en-têtes est cruciale pour protéger votre application FastAPI.

En-têtes de sécurité courants et leur importance

• Content-Security-Policy (CSP) : Cet en-tête est un outil puissant pour prévenir les attaques XSS. Il vous permet de définir une liste blanche de sources à partir desquelles le navigateur est autorisé à charger des ressources telles que des scripts, des feuilles de style et des images.
• X-Frame-Options : Cet en-tête protège contre les attaques de clickjacking en empêchant votre site web d'être intégré dans un cadre sur un autre site web.
• Strict-Transport-Security (HSTS) : Cet en-tête force le navigateur à toujours utiliser HTTPS lors de l'accès à votre site web, empêchant les attaques de l'homme du milieu.
• X-Content-Type-Options : Cet en-tête empêche le navigateur d'interpréter les fichiers comme un type MIME différent de celui déclaré dans l'en-tête Content-Type, atténuant les vulnérabilités d'analyse MIME.
• Referrer-Policy : Cet en-tête contrôle la quantité d'informations de référent (l'URL de la page précédente) qui est envoyée avec les requêtes.
• Permissions-Policy (anciennement Feature-Policy) : Cet en-tête vous permet de contrôler quelles fonctionnalités du navigateur (par exemple, caméra, microphone, géolocalisation) sont autorisées à être utilisées sur votre site web.

Définir les en-têtes de sécurité dans FastAPI

Bien que FastAPI n'ait pas de middleware intégré spécifiquement pour définir les en-têtes de sécurité, vous pouvez facilement y parvenir en utilisant un middleware personnalisé ou une bibliothèque tierce comme starlette-security ou en définissant directement les en-têtes dans vos réponses.

Exemple utilisant un middleware personnalisé :

            
from fastapi import FastAPI, Request, Response
from starlette.middleware import Middleware
from starlette.responses import JSONResponse

app = FastAPI()

async def add_security_headers(request: Request, call_next):
    response: Response = await call_next(request)
    response.headers["Content-Security-Policy"] = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; object-src 'none'; media-src 'self'; frame-ancestors 'none'; upgrade-insecure-requests; block-all-mixed-content;"
    response.headers["X-Frame-Options"] = "DENY"
    response.headers["X-Content-Type-Options"] = "nosniff"
    response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
    response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains; preload"
    response.headers["Permissions-Policy"] = "geolocation=(), camera=(), microphone=()"
    return response


app.middleware("http")(add_security_headers)


@app.get("/")
async def read_root():
    return {"message": "Hello, World!"}


            

              
                Copy
              
            
          

Dans cet exemple, le middleware add_security_headers est ajouté à l'application FastAPI. Ce middleware intercepte chaque requête et ajoute les en-têtes de sécurité spécifiés à la réponse. Décomposons les en-têtes :

• Content-Security-Policy : Il s'agit d'un en-tête complexe qui définit les sources autorisées pour différents types de ressources. Dans cet exemple, il autorise les ressources de la même origine ('self'), les scripts et styles intégrés ('unsafe-inline' - à utiliser avec prudence), les URI de données pour les images (data:), et interdit les éléments objet (object-src 'none'). Il définit également frame-ancestors 'none' pour empêcher le clickjacking. upgrade-insecure-requests indique au navigateur de mettre à niveau toutes les URL non sécurisées (HTTP) vers HTTPS. block-all-mixed-content empêche le navigateur de charger tout contenu mixte (contenu HTTP sur une page HTTPS). Il est crucial de personnaliser cet en-tête pour qu'il corresponde aux besoins spécifiques de votre application. Des configurations CSP incorrectes peuvent casser votre site web.
• X-Frame-Options : Défini sur DENY pour empêcher la page d'être encadrée par n'importe quel domaine. Alternativement, SAMEORIGIN autorise l'encadrement uniquement par le même domaine.
• X-Content-Type-Options : Défini sur nosniff pour empêcher le sniffing MIME.
• Referrer-Policy : Défini sur strict-origin-when-cross-origin pour envoyer l'origine (protocole + hôte) comme référent lors de la navigation vers une autre origine, et aucun référent lors de la navigation vers la même origine.
• Strict-Transport-Security : Définit une politique qui force le navigateur à utiliser HTTPS pendant une durée spécifiée (max-age). includeSubDomains garantit que tous les sous-domaines sont également protégés par HTTPS. preload permet d'inclure le domaine dans la liste de préchargement HSTS, qui est intégrée aux navigateurs. Notez que l'utilisation de preload nécessite que votre site ait été soumis et accepté par la liste de préchargement HSTS.
• Permissions-Policy : Spécifie quelles fonctionnalités (par exemple, géolocalisation, caméra, microphone) sont autorisées à être utilisées dans le navigateur. Dans cet exemple, toutes sont interdites.

Considérations clés pour les en-têtes de sécurité :

• Personnalisez Content-Security-Policy avec soin : C'est l'en-tête de sécurité le plus complexe, et il est crucial de le configurer correctement pour éviter de casser votre site web. Utilisez un générateur ou un validateur CSP pour vous aider à créer une politique sûre et efficace.
• Testez vos en-têtes de sécurité : Utilisez des outils en ligne comme SecurityHeaders.com pour tester les en-têtes de sécurité de votre site web et identifier les problèmes potentiels.
• Surveillez vos en-têtes de sécurité : Surveillez régulièrement vos en-têtes de sécurité pour vous assurer qu'ils sont toujours efficaces et qu'aucun changement n'est nécessaire.
• Envisagez d'utiliser un réseau de diffusion de contenu (CDN) : De nombreux CDN offrent des fonctionnalités de gestion des en-têtes de sécurité intégrées, ce qui peut simplifier le processus de définition et de maintenance de vos en-têtes de sécurité.

Au-delà de CORS et des en-têtes de sécurité

Bien que CORS et les en-têtes de sécurité soient essentiels à la sécurité des API, ce ne sont pas les seules mesures que vous devez prendre. D'autres considérations de sécurité importantes incluent :

• Authentification et autorisation : Mettez en œuvre des mécanismes d'authentification et d'autorisation robustes pour vous assurer que seuls les utilisateurs autorisés peuvent accéder à votre API. Envisagez d'utiliser OAuth 2.0 ou JWT (JSON Web Tokens) pour l'authentification.
• Validation des entrées : Validez toutes les entrées utilisateur pour prévenir les attaques par injection (par exemple, injection SQL, XSS).
• Limitation du débit : Mettez en œuvre une limitation du débit pour prévenir les attaques par déni de service (DoS).
• Journalisation et surveillance : Enregistrez toutes les requêtes d'API et surveillez votre API pour toute activité suspecte.
• Audits de sécurité réguliers : Effectuez des audits de sécurité réguliers pour identifier et corriger toute vulnérabilité potentielle.
• Maintenez les dépendances à jour : Mettez régulièrement à jour votre version de FastAPI et toutes ses dépendances pour corriger les vulnérabilités de sécurité.

Conclusion

La sécurisation de vos API FastAPI nécessite une approche à multiples facettes. En mettant en œuvre CORS correctement et en définissant des en-têtes de sécurité appropriés, vous pouvez réduire considérablement le risque de diverses vulnérabilités web. N'oubliez pas de revoir et de mettre à jour régulièrement votre configuration de sécurité pour suivre le rythme des menaces en constante évolution. Adopter une stratégie de sécurité complète, comprenant l'authentification, la validation des entrées, la limitation du débit et la surveillance, est crucial pour créer des API robustes et sécurisées qui protègent vos utilisateurs et vos données. La mise en œuvre de ces mesures, bien que potentiellement complexe, est un investissement nécessaire pour assurer la sécurité et la stabilité à long terme de vos applications dans le paysage des menaces actuel.